<?xml version="1.0" encoding="utf-8" ?>
<DataSet1 xmlns="http://tempuri.org/DataSet1.xsd">
	<manpage>
		<cmdname>abs</cmdname>
		<description>
			<![CDATA[

<h1>abs</h1>
<p>returns the absolute value of a number. this command accepts complex numbers also in every calculation mode.</p>
<h2>parameters:</h2>
<ol>
  <li>a floating point number or a complex number</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>add</cmdname>
		<description>
			<![CDATA[

<h1>add</h1>
<p>adds numbers together.</p>
<h2>parameters:</h2>
<ul>
  <li>arguments are unlimited, but at least one is required.</li>
</ul>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>apercent</cmdname>
		<description>
			<![CDATA[

<h1>apercent</h1>
<p>returns the percent ratio between two values, inverse function of percent.</p>
<h2>parameters:</h2>
<ul>
  <li>two arguments are requried.</li>
</ul>
<p>the ratio is compared to the first argument.</p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>arccos</cmdname>
		<description>
			<![CDATA[

<h1>arccos</h1>
<p>the inverse function of cosine. returns the angle of a given a number in a mode specified by the mode command. for more information see the manual page of the mode command </p>
<h2>parameters:</h2>

<ol>
<li>a floating point number between 0 and 1 </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>arccosh</cmdname>
		<description>
			<![CDATA[

<h1>arccosh</h1>
<p>the inverse function of hyperbolic cosine. returns the angle of a given a number in a mode specified by the mode command. for more information see the manual page of the mode command </p>
<h2>parameters:</h2>
<ol>
  <li>a floating point number</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>arcsin</cmdname>
		<description>
			<![CDATA[

<h1>arcsin</h1>
<p>the inverse function of sine. returns the angle of a given a number in a mode specified by the mode command. for more information see the manual page of the mode command.</p>
<h2>parameters:</h2>
<ol>
<li>a floating point value between 0 and 1 </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>arcsinh</cmdname>
		<description>
			<![CDATA[

<h1>arcsinh</h1>
<p>the inverse function of hyperbolic sine. returns the angle of a given a number in a mode   specified by the mode command. for more information see the manual page of the   mode command.</p>
<h2>parameters:</h2>
<ol>
  <li>a floating point number</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>arctan</cmdname>
		<description>
			<![CDATA[

<h1>arctan</h1>
<p>the inverse function of tangent. returns the angle of a given a number in a mode specified by the mode command. for more information see the manual page of the mode command </p>
<h2>parameters:</h2>
<ol>
<li>a floating point number </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>arctanh</cmdname>
		<description>
			<![CDATA[

<h1>arctanh</h1>
<p>the inverse function of hyperbolic tangent. returns the angle of a given a number in a mode   specified by the mode command. for more information see the manual page of the   mode command</p>
<h2>parameters:</h2>
<ol>
  <li>a floating point number</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>b_and</cmdname>
		<description>
			<![CDATA[

<h1>b_and</h1>
<p>binary and operation on two numbers or sets. </p>
<p> displays the result in decimal system. if the numbers have no floating point parts (they are integers), then the program treats them as 64 bit integer values. however, if one of the numbers have a floating point part, then both numbers are treated as 64bit double precision numbers. (ieee 754) 64 bit integer range is from: -9 223 372 036 854 755 808 to 9 223 372 036 854 755 807 </p>
<p>if used on sets, and the input sets don't have the same amount of elements, then the result set will have as elements, as set wich has the least elements of the two. </p>
<table border="0">
  <tr>
    <td align="center">a</td>
    <td align="center">b</td>
    <td align="center">a <strong>and</strong> b </td>
  </tr>
  <tr>
    <td align="center">0</td>
    <td align="center">0</td>
    <td align="center">0</td>
  </tr>
  <tr>
    <td align="center">0</td>
    <td align="center">1</td>
    <td align="center">0</td>
  </tr>
  <tr>
    <td align="center">1</td>
    <td align="center">0</td>
    <td align="center">0</td>
  </tr>
  <tr>
    <td align="center">1</td>
    <td align="center">1</td>
    <td align="center">1</td>
  </tr>
</table>
<h2>parameters:</h2>
<ol>
  <li>the first number, or a set name </li>
<li>the second number, or a set name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>b_eq</cmdname>
		<description>
			<![CDATA[
<h1>b_eq</h1>
<p>binary  
  <!--me-->
  equality 
operation on two numbersor sets. </p>
<p> displays the result in decimal system. if the numbers have no floating point parts (they are integers), then the program treats them as 64 bit integer values. however, if one of the numbers have a floating point part, then both numbers are treated as 64bit double precision numbers. (ieee 754) 64 bit integer range is from: -9 223 372 036 854 755 808 to 9 223 372 036 854 755 807 </p>
<p>if used on sets, and the input sets don't have the same amount of elements, then the result set will have as elements, as set wich has the least elements of the two. </p>
<table border="0">
  <tr>
    <td align="center">a</td>
    <td align="center">b</td>
    <td align="center">a<strong> eq </strong>b </td>
  </tr>
  <tr>
    <td align="center">0</td>
    <td align="center">0</td>
    <td align="center">1</td>
  </tr>
  <tr>
    <td align="center">0</td>
    <td align="center">1</td>
    <td align="center">0</td>
  </tr>
  <tr>
    <td align="center">1</td>
    <td align="center">0</td>
    <td align="center">0</td>
  </tr>
  <tr>
    <td align="center">1</td>
    <td align="center">1</td>
    <td align="center">1</td>
  </tr>
</table>
<h2>parameters:</h2>
<ol>
  <li>the first number, or a set name </li>
<li>the second number, or a set name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>b_nand</cmdname>
		<description>
			<![CDATA[
<h1>b_nand</h1>
<p>binary nand (negated and) operation on two numbers or sets. </p>
<p> displays the result in decimal system. if the numbers have no floating point parts (they are integers), then the program treats them as 64 bit integer values. however, if one of the numbers have a floating point part, then both numbers are treated as 64bit double precision numbers. (ieee 754) 64 bit integer range is from: -9 223 372 036 854 755 808 to 9 223 372 036 854 755 807 </p>
<p>if used on sets, and the input sets don't have the same amount of elements, then the result set will have as elements, as set wich has the least elements of the two. </p>
<table border="0">
  <tr>
    <td align="center">a</td>
    <td align="center">b</td>
    <td align="center">a<strong> nand </strong>b </td>
  </tr>
  <tr>
    <td align="center">0</td>
    <td align="center">0</td>
    <td align="center">1</td>
  </tr>
  <tr>
    <td align="center">0</td>
    <td align="center">1</td>
    <td align="center">1</td>
  </tr>
  <tr>
    <td align="center">1</td>
    <td align="center">0</td>
    <td align="center">1</td>
  </tr>
  <tr>
    <td align="center">1</td>
    <td align="center">1</td>
    <td align="center">0</td>
  </tr>
</table>
<h2>parameters:</h2>
<ol>
  <li>the first number, or a set name </li>
<li>the second number, or a set name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>b_nor</cmdname>
		<description>
			<![CDATA[

<h1>b_nor</h1>
<p>binary nor (negated or) operation on two numbersor sets. </p>
<p> displays the result in decimal system. if the numbers have no floating point parts (they are integers), then the program treats them as 64 bit integer values. however, if one of the numbers have a floating point part, then both numbers are treated as 64bit double precision numbers. (ieee 754) 64 bit integer range is from: -9 223 372 036 854 755 808 to 9 223 372 036 854 755 807 </p>
<p>if used on sets, and the input sets don't have the same amount of elements, then the result set will have as elements, as set wich has the least elements of the two. </p>
<table border="0">
  <tr>
    <td align="center">a</td>
    <td align="center">b</td>
    <td align="center">a <strong>nor </strong>b </td>
  </tr>
  <tr>
    <td align="center">0</td>
    <td align="center">0</td>
    <td align="center">1</td>
  </tr>
  <tr>
    <td align="center">0</td>
    <td align="center">1</td>
    <td align="center">0</td>
  </tr>
  <tr>
    <td align="center">1</td>
    <td align="center">0</td>
    <td align="center">0</td>
  </tr>
  <tr>
    <td align="center">1</td>
    <td align="center">1</td>
    <td align="center">0</td>
  </tr>
</table>
<h2>parameters:</h2>
<ol>
  <li>the first number, or a set name </li>
<li>the second number, or a set name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>b_not</cmdname>
		<description>
			<![CDATA[

<h1>b_not</h1>
<p>binary negation operation on a number or set.</p>
<p>displays the result in decimal system. if the number has no floating point part (it is an integer), then the program treats it as 64 bit integer value. however, if  the number has a floating point part, then the number is treated as a 64bit double precision number. (ieee 754) 64 bit integer range is from: -9 223 372 036 854 755 808 to 9 223 372 036 854 755 807 </p>
<table border="0">
  <tr>
    <td align="center">a</td>
    <td align="center"><strong>not</strong> a</td>
  </tr>
  <tr>
    <td align="center">0</td>
    <td align="center">1</td>
  </tr>
  <tr>
    <td align="center">1</td>
    <td align="center">0</td>
  </tr>
</table>
<h2>parameters:</h2>
<ol>
  <li>the number, or a set name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>b_or</cmdname>
		<description>
			<![CDATA[
<h1>b_or</h1>
<p>binary or operation on two numbers or sets. </p>
<p> displays the result in decimal system. if the numbers have no floating point parts (they are integers), then the program treats them as 64 bit integer values. however, if one of the numbers have a floating point part, then both numbers are treated as 64bit double precision numbers. (ieee 754) 64 bit integer range is from: -9 223 372 036 854 755 808 to 9 223 372 036 854 755 807 </p>
<p>if used on sets, and the input sets don't have the same amount of elements, then the result set will have as elements, as set wich has the least elements of the two. </p>
<table border="0">
  <tr>
    <td align="center">a</td>
    <td align="center">b</td>
    <td align="center">a<strong>or </strong>b </td>
  </tr>
  <tr>
    <td align="center">0</td>
    <td align="center">0</td>
    <td align="center">0</td>
  </tr>
  <tr>
    <td align="center">0</td>
    <td align="center">1</td>
    <td align="center">1</td>
  </tr>
  <tr>
    <td align="center">1</td>
    <td align="center">0</td>
    <td align="center">1</td>
  </tr>
  <tr>
    <td align="center">1</td>
    <td align="center">1</td>
    <td align="center">1</td>
  </tr>
</table>
<h2>parameters:</h2>
<ol>
  <li>the first number, or a set name </li>
<li>the second number, or a set name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>b_shl</cmdname>
		<description>
			<![CDATA[

<h1>b_shl</h1>
<p>binary shift left. </p>
<p>shifts the given number's bits, or every elements bits (if used on a set) with the second parameter in left direction. </p>
<p>if the number has no floating point part (it is an integer), then the program treats it as 64 bit integer value. however, if  the number has a floating point part, then the number is treated as a 64bit double precision number. (ieee 754) 64 bit integer range is from: -9 223 372 036 854 755 808 to 9 223 372 036 854 755 807 </p>
<p>example:<br />
  b_shl 1 4 produces 8, because: 1 on 4 bits (in binary system) is 0001. this shifted by four digits is: 1000, which is 8 in 
    <!--me--> decimal system.
</p>
<h2>parameters:</h2>
<ol>
  <li>the number to shift, or a set name </li>
  <li>the digits you want to shift. </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>b_shr</cmdname>
		<description>
			<![CDATA[

<h1>b_shr</h1>
<p>binary shift right. </p>
<p>shifts the given number's bits, or every elements bits (if used on a set) with the second parameter in right direction. </p>
<p>if the number has no floating point part (it is an integer), then the program treats it as 64 bit integer value. however, if  the number has a floating point part, then the number is treated as a 64bit double precision number. (ieee 754) 64 bit integer range is from: -9 223 372 036 854 755 808 to 9 223 372 036 854 755 807 </p>
<p>example:<br />
b_shl 8 4 produces 1, because: 8 on 4 bits (in binary system) is 1000. this shifted by four digits is: 0001, which is 1 in 
    <!--me-->
decimal system. </p>
<h2>parameters:</h2>
<ol>
  <li>the number to shift, or a set name </li>
  <li>the digits you want to shift.</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>b_xor</cmdname>
		<description>
			<![CDATA[

<h1>b_xor</h1>
<p>binary xor (exclusive or) operation on two numbers or sets. </p>
<p> displays the result in decimal system. if the numbers have no floating point parts (they are integers), then the program treats them as 64 bit integer values. however, if one of the numbers have a floating point part, then both numbers are treated as 64bit double precision numbers. (ieee 754) 64 bit integer range is from: -9 223 372 036 854 755 808 to 9 223 372 036 854 755 807 </p>
<p>if used on sets, and the input sets don't have the same amount of elements, then the result set will have as elements, as set wich has the least elements of the two. </p>
<table border="0">
  <tr>
    <td align="center">a</td>
    <td align="center">b</td>
    <td align="center">a <strong>xor </strong>b </td>
  </tr>
  <tr>
    <td align="center">0</td>
    <td align="center">0</td>
    <td align="center">0</td>
  </tr>
  <tr>
    <td align="center">0</td>
    <td align="center">1</td>
    <td align="center">1</td>
  </tr>
  <tr>
    <td align="center">1</td>
    <td align="center">0</td>
    <td align="center">1</td>
  </tr>
  <tr>
    <td align="center">1</td>
    <td align="center">1</td>
    <td align="center">0</td>
  </tr>
</table>
<h2>parameters:</h2>
<ol>
  <li>the first number, or a set name </li>
<li>the second number, or a set name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>chcode</cmdname>
		<description>
			<![CDATA[

<h1>chcode</h1>
<p>returns the utf-16 character code of a single character.</p>
<h2>parameters:</h2>
<ol>
  <li>a character</li>
</ol>
<p>if you enter more than one
characters only the first will be processed.</p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>clear</cmdname>
		<description>
			<![CDATA[

<h1>clear</h1>
<p>clears the command line screen.</p>
<h2>parameters:</h2>
<p>no parameters are required</p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>cmdlist</cmdname>
		<description>
			<![CDATA[

<h1>cmdlist</h1>
<p>displays the supported functions as a list on the command line.</p>
<h2>parameters:</h2>
<p>no parameters are required</p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>comb_norep</cmdname>
		<description>
			<![CDATA[

<h1>comb_norep</h1>
<p>calculate a combination without repeat. </p>
<h2>parameters:</h2>
<ol>
  <li>the number of all elements (n)</li>
  <li>the number of elements, which are chosen from all of the elements (k) </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>comb_rep</cmdname>
		<description>
			<![CDATA[

<h1>comb_rep</h1>
<p>calculate a combination with repeat. </p>
<h2>parameters:</h2>
<ol>
  <li>the number of all elements (n) </li>
  <li>the  number of repeating elements (k)  </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>constant variables</cmdname>
		<description>
			<![CDATA[

<h1>constant variables </h1>
<p>there are two variables in the program defined with a constant value. these values can't be changed for security reasons and their names canot be used as a name for a variable. these variables are:</p>
<ul>
<li>$pi (the value of pi ~3,14)</li>
<li>$e (euler's number) </li>
</ul>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>convert</cmdname>
		<description>
			<![CDATA[

<h1>convert</h1>
<p>preforms number system conversion.</p>
<h2>parameters:</h2>
<ol>
  <li>the source system</li>
  <li>the destination system</li>
  <li>the number itself, in a representation of the source system </li>
</ol>
<p>the source and destination systems can be one of the folowing: 2, 8, 10, 16, or 16f or 16d</p>
<p>the 16f system converts the number to a ieee 754 float number represented in hexadecimal form, the 16d system is similar, but it converts to ieee 754 double.</p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>cos</cmdname>
		<description>
			<![CDATA[

<h1>cos</h1>
<p>returns the cosine of a number. treats the input number as it's set by the mode command. for more information see the manual of the mode command. </p>
<h2>parameters:</h2>
<ol>
  <li>an angle</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>cosh</cmdname>
		<description>
			<![CDATA[

<h1>cosh</h1>
<p>returns the hyperbolic cosinus of a number. treats the input number as it's set by the   mode command. for more information see the manual of the mode command. </p>
<h2>parameters:</h2>
<ol>
  <li>an angle </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>ctg</cmdname>
		<description>
			<![CDATA[

<h1>ctg</h1>
<p>returns the cotangent of a number. treats the input number as it's set by the mode command. for more information see the manual of the mode command. </p>
<h2>parameters:</h2>
<ol>
  <li>the angle.</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>currency</cmdname>
		<description>
			<![CDATA[

<h1>currency</h1>
<p>calculate a given kind of  currency to another kind. to use this function you must be connected to the internet!</p>
<h2>parameters:</h2>
<ol>
  <li>the currency amount</li>
  <li>source currency</li>
  <li>target currency</li>
</ol>
<p>the source and target currency can be given by it's 3 digit iso code. the following codes can be used:</p>
<table border="1">
<tr>
<td>afa</td>
<td>afghanistan afghani</td>
</tr><tr>
<td>all</td>
<td>albanian lek</td>
</tr>
<tr>
<td>dzd</td>
<td>algerian dinar</td>
</tr>
<tr>
<td>ars</td>
<td>argentine peso</td>
</tr>
<tr>
<td>awg</td>
<td>aruba florin</td>
</tr>
<tr>
<td>aud</td>
<td>australian dollar</td>
</tr>
<tr>
<td>bsd</td>
<td>bahamian dollar</td>
</tr>
<tr>
<td>bhd</td>
<td>bahraini dinar</td>
</tr>
<tr>
<td>bdt</td>
<td>bangladesh taka</td>
</tr>
<tr>
<td>bbd</td>
<td>barbados dollar</td>
</tr>
<tr>
<td>bzd</td>
<td>belize dollar</td>
</tr>
<tr>
<td>bmd</td>
<td>bermuda dollar</td>
</tr>
<tr>
<td>btn</td>
<td>bhutan ngultrum</td>
</tr>
<tr>
<td>bob</td>
<td>bolivian boliviano</td>
</tr>
<tr>
<td>bwp</td>
<td>botswana pula</td>
</tr>
<tr>
<td>brl</td>
<td>brazilian real</td>
</tr>
<tr>
<td>gbp</td>
<td>british pound</td>
</tr>
<tr>
<td>bnd</td>
<td>brunei dollar</td>
</tr>
<tr>
<td>bif</td>
<td>burundi franc</td>
</tr>
<tr>
<td>xof</td>
<td>cfa franc (bceao)</td>
</tr>
<tr>
<td>xaf</td>
<td>cfa franc (beac)</td>
</tr>
<tr>
<td>khr</td>
<td>cambodia riel</td>
</tr>
<tr>
<td>cad</td>
<td>canadian dollar</td>
</tr>
<tr>
<td>cve</td>
<td>cape verde escudo</td>
</tr>
<tr>
<td>kyd</td>
<td>cayman islands dollar</td>
</tr>
<tr>
<td>clp</td>
<td>chilean peso</td>
</tr>
<tr>
<td>cny</td>
<td>chinese yuan</td>
</tr>
<tr>
<td>cop</td>
<td>colombian peso</td>
</tr>
<tr>
<td>kmf</td>
<td>comoros franc</td>
</tr>
<tr>
<td>crc</td>
<td>costa rica colon</td>
</tr>
<tr>
<td>hrk</td>
<td>croatian kuna</td>
</tr>
<tr>
<td>cup</td>
<td>cuban peso</td>
</tr>
<tr>
<td>cyp</td>
<td>cyprus pound</td>
</tr>
<tr>
<td>czk</td>
<td>czech koruna</td>
</tr>
<tr>
<td>dkk</td>
<td>danish krone</td>
</tr>
<tr>
<td>djf</td>
<td>dijibouti franc</td>
</tr>
<tr>
<td>dop</td>
<td>dominican peso</td>
</tr>
<tr>
<td>xcd</td>
<td>east caribbean dollar</td>
</tr>
<tr>
<td>egp</td>
<td>egyptian pound</td>
</tr>
<tr>
<td>svc</td>
<td>el salvador colon</td>
</tr>
<tr>
<td>eek</td>
<td>estonian kroon</td>
</tr>
<tr>
<td>etb</td>
<td>ethiopian birr</td>
</tr>
<tr>
<td>eur</td>
<td>euro</td>
</tr>
<tr>
<td>fkp</td>
<td>falkland islands pound</td>
</tr>
<tr>
<td>gmd</td>
<td>gambian dalasi</td>
</tr>
<tr>
<td>ghc</td>
<td>ghanian cedi</td>
</tr>
<tr>
<td>gip</td>
<td>gibraltar pound</td>
</tr>
<tr>
<td>xau</td>
<td>gold ounces</td>
</tr>
<tr>
<td>gtq</td>
<td>guatemala quetzal</td>
</tr>
<tr>
<td>gnf</td>
<td>guinea franc</td>
</tr>
<tr>
<td>gyd</td>
<td>guyana dollar</td>
</tr>
<tr>
<td>htg</td>
<td>haiti gourde</td>
</tr>
<tr>
<td>hnl</td>
<td>honduras lempira</td>
</tr>
<tr>
<td>hkd</td>
<td>hong kong dollar</td>
</tr>
<tr>
<td>huf</td>
<td>hungarian forint</td>
</tr>
<tr>
<td>isk</td>
<td>iceland krona</td>
</tr>
<tr>
<td>inr</td>
<td>indian rupee</td>
</tr>
<tr>
<td>idr</td>
<td>indonesian rupiah</td>
</tr>
<tr>
<td>iqd</td>
<td>iraqi dinar</td>
</tr>
<tr>
<td>ils</td>
<td>israeli shekel</td>
</tr>
<tr>
<td>jmd</td>
<td>jamaican dollar</td>
</tr>
<tr>
<td>jpy</td>
<td>japanese yen</td>
</tr>
<tr>
<td>jod</td>
<td>jordanian dinar</td>
</tr>
<tr>
<td>kzt</td>
<td>kazakhstan tenge</td>
</tr>
<tr>
<td>kes</td>
<td>kenyan shilling</td>
</tr>
<tr>
<td>krw</td>
<td>korean won</td>
</tr>
<tr>
<td>kwd</td>
<td>kuwaiti dinar</td>
</tr>
<tr>
<td>lak</td>
<td>lao kip</td>
</tr>
<tr>
<td>lvl</td>
<td>latvian lat</td>
</tr>
<tr>
<td>lbp</td>
<td>lebanese pound</td>
</tr>
<tr>
<td>lsl</td>
<td>lesotho loti</td>
</tr>
<tr>
<td>lrd</td>
<td>liberian dollar</td>
</tr>
<tr>
<td>lyd</td>
<td>libyan dinar</td>
</tr>
<tr>
<td>ltl</td>
<td>lithuanian lita</td>
</tr>
<tr>
<td>mop</td>
<td>macau pataca</td>
</tr>
<tr>
<td>mkd</td>
<td>macedonian denar</td>
</tr>
<tr>
<td>mgf</td>
<td>malagasy franc</td>
</tr>
<tr>
<td>mwk</td>
<td>malawi kwacha</td>
</tr>
<tr>
<td>myr</td>
<td>malaysian ringgit</td>
</tr>
<tr>
<td>mvr</td>
<td>maldives rufiyaa</td>
</tr>
<tr>
<td>mtl</td>
<td>maltese lira</td>
</tr>
<tr>
<td>mro</td>
<td>mauritania ougulya</td>
</tr>
<tr>
<td>mur</td>
<td>mauritius rupee</td>
</tr>
<tr>
<td>mxn</td>
<td>mexican peso</td>
</tr>
<tr>
<td>mdl</td>
<td>moldovan leu</td>
</tr>
<tr>
<td>mnt</td>
<td>mongolian tugrik</td>
</tr>
<tr>
<td>mad</td>
<td>moroccan dirham</td>
</tr>
<tr>
<td>mzm</td>
<td>mozambique metical</td>
</tr>
<tr>
<td>mmk</td>
<td>myanmar kyat</td>
</tr>
<tr>
<td>nad</td>
<td>namibian dollar</td>
</tr>
<tr>
<td>npr</td>
<td>nepalese rupee</td>
</tr>
<tr>
<td>ang</td>
<td>neth antilles guilder</td>
</tr>
<tr>
<td>nzd</td>
<td>new zealand dollar</td>
</tr>
<tr>
<td>nio</td>
<td>nicaragua cordoba</td>
</tr>
<tr>
<td>ngn</td>
<td>nigerian naira</td>
</tr>
<tr>
<td>kpw</td>
<td>north korean won</td>
</tr>
<tr>
<td>nok</td>
<td>norwegian krone</td>
</tr>
<tr>
<td>omr</td>
<td>omani rial</td>
</tr>
<tr>
<td>xpf</td>
<td>pacific franc</td>
</tr>
<tr>
<td>pkr</td>
<td>pakistani rupee</td>
</tr>
<tr>
<td>xpd</td>
<td>palladium ounces</td>
</tr>
<tr>
<td>pab</td>
<td>panama balboa</td>
</tr>
<tr>
<td>pgk</td>
<td>papua new guinea kina</td>
</tr>
<tr>
<td>pyg</td>
<td>paraguayan guarani</td>
</tr>
<tr>
<td>pen</td>
<td>peruvian nuevo sol</td>
</tr>
<tr>
<td>php</td>
<td>philippine peso</td>
</tr>
<tr>
<td>xpt</td>
<td>platinum ounces</td>
</tr>
<tr>
<td>pln</td>
<td>polish zloty</td>
</tr>
<tr>
<td>qar</td>
<td>qatar rial</td>
</tr>
<tr>
<td>rol</td>
<td>romanian leu</td>
</tr>
<tr>
<td>rub</td>
<td>russian rouble</td>
</tr>
<tr>
<td>wst</td>
<td>samoa tala</td>
</tr>
<tr>
<td>std</td>
<td>sao tome dobra</td>
</tr>
<tr>
<td>sar</td>
<td>saudi arabian riyal</td>
</tr>
<tr>
<td>scr</td>
<td>seychelles rupee</td>
</tr>
<tr>
<td>sll</td>
<td>sierra leone leone</td>
</tr>
<tr>
<td>xag</td>
<td>silver ounces</td>
</tr>
<tr>
<td>sgd</td>
<td>singapore dollar</td>
</tr>
<tr>
<td>skk</td>
<td>slovak koruna</td>
</tr>
<tr>
<td>sit</td>
<td>slovenian tolar</td>
</tr>
<tr>
<td>sbd</td>
<td>solomon islands dollar</td>
</tr>
<tr>
<td>sos</td>
<td>somali shilling</td>
</tr>
<tr>
<td>zar</td>
<td>south african rand</td>
</tr>
<tr>
<td>lkr</td>
<td>sri lanka rupee</td>
</tr>
<tr>
<td>shp</td>
<td>st helena pound</td>
</tr>
<tr>
<td>sdd</td>
<td>sudanese dinar</td>
</tr>
<tr>
<td>srg</td>
<td>surinam guilder</td>
</tr>
<tr>
<td>szl</td>
<td>swaziland lilageni</td>
</tr>
<tr>
<td>sek</td>
<td>swedish krona</td>
</tr>
<tr>
<td>try</td>
<td>turkey lira</td>
</tr>
<tr>
<td>chf</td>
<td>swiss franc</td>
</tr>
<tr>
<td>syp</td>
<td>syrian pound</td>
</tr>
<tr>
<td>twd</td>
<td>taiwan dollar</td>
</tr>
<tr>
<td>tzs</td>
<td>tanzanian shilling</td>
</tr>
<tr>
<td>thb</td>
<td>thai baht</td>
</tr>
<tr>
<td>top</td>
<td>tonga pa'anga</td>
</tr>
<tr>
<td>ttd</td>
<td>trinidad&amp;amp;tobago dollar</td>
</tr>
<tr>
<td>tnd</td>
<td>tunisian dinar</td>
</tr>
<tr>
<td>trl</td>
<td>turkish lira</td>
</tr>
<tr>
<td>usd</td>
<td>u.s. dollar</td>
</tr>
<tr>
<td>aed</td>
<td>uae dirham</td>
</tr>
<tr>
<td>ugx</td>
<td>ugandan shilling</td>
</tr>
<tr>
<td>uah</td>
<td>ukraine hryvnia</td>
</tr>
<tr>
<td>uyu</td>
<td>uruguayan new peso</td>
</tr>
<tr>
<td>vuv</td>
<td>vanuatu vatu</td>
</tr>
<tr>
<td>veb</td>
<td>venezuelan bolivar</td>
</tr>
<tr>
<td>vnd</td>
<td>vietnam dong</td>
</tr>
<tr>
<td>yer</td>
<td>yemen riyal</td>
</tr>
<tr>
<td>yum</td>
<td>yugoslav dinar</td>
</tr>
<tr>
<td>zmk</td>
<td>zambian kwacha</td>
</tr>
<tr>
<td>zwd</td>
<td>zimbabwe dollar</td>
</tr>
</table>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>define</cmdname>
		<description>
			<![CDATA[

<h1>define</h1>
<p>creates a user function, with the function editor. if the specified function name exists, then it opens it for editing. functions can contain valid calc# instructions. each instruction must be written in a row. </p>
<h2>parameters:</h2>
<ol>
  <li>a function name to define. </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>deg2grad</cmdname>
		<description>
			<![CDATA[

<h1>deg2grad</h1>
<p>converts given degrees to gradians. the inverse function of grad2deg. this   function ignores the calculator mode.</p>
<h2>parameters:</h2>
<ol>
  <li>an angle in degrees.</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>deg2rad</cmdname>
		<description>
			<![CDATA[

<h1>deg2rad</h1>
<p>converts given degrees to radians. the inverse function of rad2deg. this function
ignores the calculator mode</p>
<h2>parameters:</h2>
<ol>
  <li>a number in degrees</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>derive</cmdname>
		<description>
			<![CDATA[

<h1>derive</h1>
<p>preform numerical derivation on a single parameter function. note: numerical derivation algorithms can't be acurate, so use this function with caution. (may return wrong results) </p>
<h2>parameters:</h2>
<ol>
  <li>the function (an expression parseable by the eval command)</li>
  <li>the derivation point</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>div</cmdname>
		<description>
			<![CDATA[

<h1>div</h1>
<p>divides numbers.</p>
<h2>parameters:</h2>
<ul>
  <li>arguments are unlimited, but at least one is required.</li>
</ul>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>dock</cmdname>
		<description>
			<![CDATA[

<h1>dock</h1>
<p>docks the program to the desktop. if the program is in docked state, it restores the default view. </p>
<h2>parameters:</h2>
<p>no parameters are required</p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>echo</cmdname>
		<description>
			<![CDATA[

<h1>echo</h1>
<p>writes a string to the command line.</p>
<h2>parameters:</h2>
<p>if the string contains a valid variable name (separated from the rest of the 
text with spaces), then it's value is displayed instead of it's name.</p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>eval</cmdname>
		<description>
			<![CDATA[

<h1>eval</h1>
<p>evaluate a string as a mathematical expression.</p>
<p><strong>supported operators:</strong></p>
<table width="80%" border="1">
  <tr valign="top">
    <td width="20%"><p align="center"><strong>operator character: </strong></p></td>
    <td width="80%"><p><strong>meaning</strong></p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">+</p></td>
    <td width="80%"><p>addiction</p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">-</p></td>
    <td width="80%"><p>substraction</p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">*</p></td>
    <td width="80%"><p>multiplication</p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">/</p></td>
    <td width="80%"><p>division</p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">( )</p></td>
    <td width="80%"><p>kifejez&eacute;sek z&aacute;r&oacute;jelez&eacute;se</p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">;</p></td>
    <td width="80%"><p>parameter sepperator for function parameters </p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">%</p></td>
    <td width="80%"><p>mod</p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">!=</p></td>
    <td width="80%"><p>logical not equality </p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">=</p></td>
    <td width="80%"><p>logical equality </p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">and</p></td>
    <td width="80%"><p>logical and</p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">or</p></td>
    <td width="80%"><p>logical or </p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">&lt;</p></td>
    <td width="80%"><p>smaller than </p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">&gt;</p></td>
    <td width="80%"><p>bigger than </p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">^</p></td>
    <td width="80%"><p>pow</p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">&amp;</p></td>
    <td width="80%"><p>bitwise and </p></td>
  </tr>
  <tr valign="top">
    <td width="20%"><p align="center">|</p></td>
    <td width="80%"><p>bitwise or</p>
    </td>
  </tr>
    <tr valign="top">
    <td width="20%"><p align="center">:=</p></td>
    <td width="80%"><p>set a variable with a value. example: $var:=5+2</p>
    </td>
  </tr>
</table>
<p><strong>supported functions:</strong></p>
<table width="80%" border="1">
  <tr>
    <td width="33%"><ul>
      <li>abs</li>
      <li>apercent</li>
      <li>arccos</li>
      <li>arccosh</li>
      <li>arcsin</li>
      <li>arcsinh</li>
      <li>arctan</li>
      <li>arctanh</li>
      <li>cos</li>
      <li>cosh</li>
    </ul></td>
    <td width="33%"><ul>
      <li>ctg</li>
      <li>deg2grad</li>
      <li>deg2rad</li>
      <li>fact</li>
      <li>gcd</li>
      <li>grad2deg</li>
      <li>isprime</li>
      <li>lcm</li>
      <li>log</li>
      <li>percent</li>
    </ul>
    </td>
    <td width="33%"><ul>
      <li>rad2deg</li>
      <li>round</li>
      <li>sign</li>
      <li>sin</li>
      <li>sinh</li>
      <li>sqr</li>
      <li>tan</li>
      <li>tanh</li>
    </ul>
    </td>
  </tr>
</table>
<p>for further usage and parameters of the supported functions use it's manpage. if a function requires two or more parameters the ; sign is used to separate the parameters instead of the , sign, because in some countries , is used in floating point numbers instead of the . sign. </p>
<h2>parameters:</h2>
<ol>
  <li>the string to be interpreted. example sin(3+2) </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>exec</cmdname>
		<description>
			<![CDATA[

<h1>exec</h1>
<p>executes a program. </p>
<h2>parameters:</h2>
<ol>
  <li>the filename of the program to be run</li>
</ol>
<p>the program file
must be in the prgs subdirectory of calc#. program files are simple text files
which contain calc# instructions. comments can be added to the program files.
a whole line can be commented with the ; mark at the beginning of the row.
the rest of the parameters are passed to the program as arguments. the first
argument can be accessed as $1 and so the others. these arguments are passed
trough the main memory, so if you set a variable as $1 it's value will be
overwritten at the execution and will be erased  at the end of the program.</p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>exit</cmdname>
		<description>
			<![CDATA[

<h1>exit</h1>
<p>exits the program</p>
<h2>parameters:</h2>
<p>no parameters are required</p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>fact</cmdname>
		<description>
			<![CDATA[

<h1>fact</h1>
<p>calculate the factorial of a number. </p>
<h2>parameters:</h2>
<ol>
  <li>the number itself </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>fibonacci</cmdname>
		<description>
			<![CDATA[

<h1>fibonacci</h1>
<p>returns the specified element of the fibonacci sequence. the first number of the sequence is 0, the second number is 1, and each  subsequent number is equal to the sum of the previous two numbers. fn = fn-1 + fn-2 </p>
<h2>parameters:</h2>
<ol>
  <li>the element you would like to get.</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>for</cmdname>
		<description>
			<![CDATA[

<h1>for</h1>
<p>repat an operation n times.  if you want to run more commands than one in a for cycle, you must put them   in a user command. </p>
<h2>parameters:</h2>
<ol>
  <li>the variable, which's vallue will be modified during the for operation</li>
  <li>the start vallue</li>
  <li>the end vallue</li>
  <li>inc or dec</li>
  <li>the command.</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>gcd</cmdname>
		<description>
			<![CDATA[

<h1>gcd</h1>
<p>returns the greatest common dividers of two numbers.</p>
<h2>parameters:</h2>
<ol>
  <li>a floating point number</li>
  <li>a floating point number</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>grad2deg</cmdname>
		<description>
			<![CDATA[

<h1>grad2deg</h1>
<p>converts given gradians to degrees . the inverse function of deg2grad. this   function ignores the calculator mode.</p>
<h2>parameters:</h2>
<ol>
  <li>an angle in gradians.</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>help</cmdname>
		<description>
			<![CDATA[

<h1>help</h1>
<p>get usage info for a command.
if you need further help call 911 or 112 depending on your country
(this text is displayed because you entered help help)</p>
<h2>parameters:</h2>
<p>no parameters are required </p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>if</cmdname>
		<description>
			<![CDATA[

<h1>if</h1>
<p>conditionaly run a command. only executes a command if the controll statement assigned to the if is true. 0 is interpreted as false, vallues greater than 1 are interpreted as true statements. if you want to run more commands than one run conditionaly, you must put them in a user command. </p>
<h2>parameters:</h2>
<ol>
  <li>the controll statement, an expression parseable by the eval command</li>
  <li>the command to run.</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>imgcompress</cmdname>
		<description>
			<![CDATA[

<h1>imgcompress</h1>
<p>saves a matrix as a compressed image. the image format is based on the file extension you give. supported formats and file extensions:</p>
<ul>
  <li>jpeg, jpg</li>
  <li>png</li>
  <li>gif (result will be only 256 colors) </li>
  <li>tif (not compresses) </li>
  <li>wmf</li>
  <li>emf</li>
</ul>
<p>note that by using compressed formats the original data may distort, however it might be useful, because it saves disk space. to save your images undistorted please use the mtrx_savef function. </p>
<h2>parameters:</h2>
<ol>
  <li>the matrix's name you want to save</li>
  <li>the target file location with extension</li>
  <li>the compression factor (only required when using jpeg compression, must be between 0 and 100, 100 is the best quality and 0 is the worst)   </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>inputing numbers</cmdname>
		<description>
			<![CDATA[

<h1>inputing numbers </h1>
<p>calc# can recognize numbers in several formats. </p>
<p>the most common number format is decimal floating point numbers. the format sepperator (. or ,) is based on your locallee, that's why the eval command (and some other commands) uses a ; symbol for sepperating function arguments. </p>
<p>numbers in octal, hexa, or binary can also be used as an input. in this case you must place an h, o, or b at the end of the number. in this input mode only integer numbers can be used.</p>
<p>all commands that require at least one number support floating point variables. because matrixes and sets use floating point numbers their elements can be used as a floating point variable. </p>
<p>normal floating point variables start with a $ symbol. if the variable is not set a 0 vallue is used in the calculation.</p>
<p>an element from a set can be used in the folowing format: @set[element], where set is the name of the set and element is the number of the element you want to use. the element must be greater 0 and less than the length of the set.</p>
<p>an element from a matrix can be used in a simmilar way, but in this case a row and a column index is required: #matrix[row, column] </p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>integrate</cmdname>
		<description>
			<![CDATA[

<h1>integrate</h1>
<p>preform numerical integration on a single parameter function. the integration is based on simpson's alogrithm </p>
<h2>parameters:</h2>
<ol>
  <li>the function (an expression parseable by the eval command)</li>
  <li>the integration's start point</li>
  <li>the integration's end point  </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>isprime</cmdname>
		<description>
			<![CDATA[

<h1>isprime</h1>
<p>tells you whether a number is a prime number or not.
returns 1 if it's a prime number, 0 if it's not a prime number</p>
<h2>parameters:</h2>
<ol>
  <li>a floating point number</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>lcm</cmdname>
		<description>
			<![CDATA[

<h1>lcm</h1>
<p>returns the least common multiple of two numbers.</p>
<h2>parameters:</h2>
<ol>
  <li>a floating point number</li>
  <li>a floating point number</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>load</cmdname>
		<description>
			<![CDATA[

<h1>load</h1>
<p>loads a file into a matrix or set. the program supports the following formats:</p>
<p><strong>sets:</strong> txt (one item per line), xml, csv</p>
<p><strong>matrixes:</strong> csv, xml, bmp, jpg, gif, png, tif </p>
<p>note: formats are recognised by the file's extension.</p>
<p><strong>additional parameters: </strong></p>
<p>when loading a set from an xml or csv you can specify additionaly the xml node name (default is: item), which contains a set item, or the csv delimiter character (default is: ; )  </p>
<p>when loading a matrix from a csv file you can specify additionaly delimiter character (default is: ; )  </p>
<h2>parameters:</h2>
<ol>
  <li>a matrix's or set's name</li>
  <li>the file to load.  </li>
  <li>additional parameter (not always required) </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>log</cmdname>
		<description>
			<![CDATA[

<h1>log</h1>
<p>calculate the logarithm of a number with a given base. </p>
<h2>parameters:</h2>
<ol>
  <li>the number that logarithm needed to be found </li>
  <li>the base number of the logarithm</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mem_clr</cmdname>
		<description>
			<![CDATA[

<h1>mem_clr</h1>
<p>clears all variables which are stored in the system memory. </p>
<h2>parameters:</h2>
<ol>
<li>the segment to be cleaned</li>
</ol>
<p>segment can be one of the folowing ones:<br />
all - clears all the segments<br />
float - clears the floating point segment <br />
mtrx - clears  the matrix segment<br />
cplx - clears the complex number segment<br />
set - clears the set segment </p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mem_dump</cmdname>
		<description>
			<![CDATA[

<h1>mem_dump</h1>
<p>dumps the stored memory vallues in a binary formated file. each memory segment is dumped into a sepperate file. to load a dump see the manual of the mem_load command. </p>
<h2>parameters:</h2>
<ol>
  <li>the target directory path, where the dump files will be written.</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mem_load</cmdname>
		<description>
			<![CDATA[

<h1>mem_load</h1>
<p>loads a memory dump made by the mem_dump command. when loading a memory dump all vallues which are stored in the memory are erased, and replaced by the vallues in the dump. to make a memory dump see the mem_dump command's manual page. </p>
<h2>parameters:</h2>
<ol>
  <li>the directory path where the dump files are located. </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mem_map</cmdname>
		<description>
			<![CDATA[

<h1>mem_map</h1>
<p>displays the mapped variables name and value. it also lists stored matrixes. if you doubleclick on the matrix's name it loads the matrix into a new matrix editor. for more information about the matrix editor see the mtrx_edit command. </p>
<h2>parameters:</h2>
<p>no parameters are required </p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mem_mov</cmdname>
		<description>
			<![CDATA[

<h1>mem_mov</h1>
<p>stores a variable to the system memory. the destination variable must begin with one of the folowing symbols: $(floating point variables), &amp; (complex numbers), # (matrixes), @ (sets), ~ (strings)</p>
<h2>parameters:</h2>
<ol>
  <li>the name of the variable (destination) </li>
  <li>the value of it. (source) </li>
</ol>
<p><u>duplicating variables:</u><br />
function can be used to duplicate existing variables. to use this feature simply specify an existing variable as source. copy is only supported on same type of variables, so you can't copy a set into a matrix, etc... </p>
<p><u>inputting variables:</u><br />
the program makes no difference between variables written in uncapitalized mode and capitalized mode. so $a and $a mean the same variable. variable names can contain letters from the english alphabet(a-z), numbers(0-9) and the _ symbol.</p>
<blockquote>
<p><u>floating point numbers:</u> the divider symbol is based on your locale</p>
<p><u>complex numbers:</u><br />
2 floating point numbers make a complex number. the numbers must be divided with a ; symbol.</p>
<p><u>matrixes:</u><br />
  matrixes must be given in the following format: each row must start with a [ symbol and end with a ] symbol. each value must be separated with a ; symbol.</p>
<p>- from a complex number. in this case the the number sets the matrix's dimensions. values are nan in the matrix. the real part is interpreted as number of rows, and the imaginary part is interpreted as the number of columns. </p>
<p><u>sets:</u><br />
  sets must start with a { symbol and end with a } symbol. between them the values must be separated with a ; symbol.<br />
  alternative ways:</p>
<blockquote>
  <p>mem_mov can create a set from a number too. in this case the number is interpreted as the set's length. the values are nan.</p>
  <p>- from a string. in this case each characters unicode code is inserted into the set. to show the text stored in a set use the echo command</p>
    </blockquote>
        <p><u>strings:</u><br />
          simply enter it's vallue. if it contains spaces, then the string must start and end with a &quot; symbol. <br />
        </p>
</blockquote>
<p><u>manipulating sets &amp; matrixes</u></p>
<blockquote>
  <p>the mem_mov command can also be used to modify a single floating point item of a set or a matrix. to use this function you need to give the destination in a format acceptable by the calculator. (for sets @set[item], where set is the name of the destination set, and item is the item which you want to modify. for matrixes: #matrix[row;column], where matrix is the destination matrix and row, column specify the element you want to modify.)</p>
</blockquote>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mem_rem</cmdname>
		<description>
			<![CDATA[

<h1>mem_rem</h1>
<p>removes a variable stored in the system memory. </p>
<h2>parameters:</h2>
<ol>
  <li>the name of the variable</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mod</cmdname>
		<description>
			<![CDATA[

<h1>mod</h1>
<p>divides numbers and returns the remainder of the division. currently works with those numbers which don't have a fractional part. for example: mod 5 2 returns 1, mod 22,02 0,2 returns some junk number.</p>
<h2>parameters:</h2>
<ul>
  <li>arguments are unlimited, but at least one is required.</li>
</ul>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mode</cmdname>
		<description>
			<![CDATA[

<h1>mode</h1>
<p>changes the calculator mode, depending on what mode 
you want to use. if the mode is deg, rad or grad it only affects the result of those functions which work with angles. if the mode is cplx, then the program expects the numbers to be complex numbers. complex numbers can be defined with the mem_mov command. </p>
<h2>parameters:</h2>
<ol>
  <li>the calculator mode. can be deg, rad, grad or cplx </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mtrx_add</cmdname>
		<description>
			<![CDATA[

<h1>mtrx_add</h1>
<p>adds two matrixes togeather. the two matrixes have to be defined first by the mem_mov command or by using the built in matrix editor. (mtrx_edit) both matrixes have to have same row and column count. </p>
<h2>parameters:</h2>
<ol>
  <li>a matrix's name </li>
  <li>a nother matrix's name</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mtrx_def</cmdname>
		<description>
			<![CDATA[

<h1>mtrx_def</h1>
<p>defines a new matrix with the given name.</p>
<h2>parameters:</h2>
<ol>
  <li>the name of the matrix. this parameter must begin with a # symbol</li>
  <li>the matrix making expression. must be given as:<br />
    [row1_number1;row1_number2;row1_numbern][rown_number1;rown_number2;rown_numbern] etc..<br />
    as you can se a row must be between [] symbols, and the numbers must be sepparated with a ; symbol.
</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mtrx_det</cmdname>
		<description>
			<![CDATA[

<h1>mtrx_det</h1>
<p>calculates the determinant of a matrix. the determinant can only be calculated if the matrix has the same number of rows and columns. the matrix has to be defined first by the mem_mov command or by using the built in matrix editor. (mtrx_edit)</p>
<h2>parameters:</h2>
<ol>
  <li>a matrix's name</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mtrx_dim</cmdname>
		<description>
			<![CDATA[

<h1>mtrx_dim</h1>
<p>returns the row and column number of a matrix as a complex number. the real part is the number of rows, and the imaginary part is the number of columns </p>
<h2>parameters:</h2>
<ol>
  <li>a matrix's name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mtrx_edit</cmdname>
		<description>
			<![CDATA[

<h1>mtrx_edit</h1>
<p>launches the built in graphical matrix editor</p>
<h2>parameters:</h2>
<ol>
  <li>the matrix name which you want to edit. it's not required.</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mtrx_gtrnsf</cmdname>
		<description>
			<![CDATA[

<h1>mtrx_gtrnsf</h1>
<p>preform a geometrical transformation on a matrix. supported transformations:</p>
<ul>
  <li>clockwise rotate by 90 degrees (rot_90cw opration flag)</li>
  <li>counter clockwise rotate by 90 degrees (rot_90ccw operation flag)</li>
  <li>horizontal flip (flip_horiz operation flag)</li>
  <li>vertical flip  (flip_vert operation flag)</li>
  <li>normal resize (resize operation flag)</li>
  <li>bilinear resize (resize_bilin operation flag)</li>
  <li>crop (crop operation flag)</li>
</ul>
<h2>parameters:</h2>
<ol>
  <li>a matrix's name</li>
  <li>an operation (se above)</li>
  <li>start row or destination row count </li>
  <li>start column or destination column count</li>
  <li>end row</li>
  <li>end column</li>
</ol>
<p>parameter 3,4 sets the starting point of the crop, or set the output matrix size when resizing. parameter 5,6 set the end point of the crop. parameter 4,5,6,7 is required only by the  croping function, a resize requries the first 4 parameters. </p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mtrx_hist</cmdname>
		<description>
			<![CDATA[

<h1>mtrx_hist</h1>
<p>creates a matrix based on a matrix,which can be used to draw histogram with the plot_data function.</p>
<h2>parameters:</h2>
<ol>
  <li>a matrix's name</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mtrx_inv</cmdname>
		<description>
			<![CDATA[

<h1>mtrx_inv</h1>
<p>calculates the inverse of a matrix </p>
<h2>parameters:</h2>
<ol>
  <li>a matrix's name</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mtrx_mul</cmdname>
		<description>
			<![CDATA[

<h1>mtrx_mul</h1>
<p>multiplies two matrixes. the two matrixes have to be defined first by the mem_mov command or by using the built in matrix editor. (mtrx_edit) the multiplier matrix has to have same number of colums as the multiplied matrix. </p>
<h2>parameters:</h2>
<ol>
  <li>a matrix's name (this will be multiplied) </li>
  <li>a nother matrix's name(this is the multiplier)</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mtrx_neg</cmdname>
		<description>
			<![CDATA[

<h1>mtrx_neg</h1>
<p>calculates the negated matrix of a matrix. </p>
<h2>parameters:</h2>
<ol>
  <li>a matrix's name</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mtrx_storage</cmdname>
		<description>
			<![CDATA[

<h1>mtrx_storage</h1>
<p>change matrix storage size. for memory saving reasons the default matrix implementation uses single precision float vallues, instead of doubles. however single precision is not always enough. so, with this command you can change the default matrix storage engine between floats and doubles. note: when changing storage size, the stored matrixes are cleared from the memory!</p>
<h2>parameters:</h2>
<ol>
  <li>single or double. single sets the storage mode to floats (32bit) and double sets the storage to doubles (64bit) </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mtrx_sub</cmdname>
		<description>
			<![CDATA[

<h1>mtrx_sub</h1>
<p>subtracts two matrixes. the two matrixes have to be defined first by the mem_mov command or by using the built in matrix editor. (mtrx_edit) both matrixes have to have same row and column count. </p>
<h2>parameters:</h2>
<ol>
  <li>a matrix's name </li>
  <li>a nother matrix's name</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mtrx_trnsf</cmdname>
		<description>
			<![CDATA[

<h1>mtrx_trnsf</h1>
<p>transforms each element of a matrix, based on an expression parseable by the eval command. in the expression $x represents the item of the matrix.<br />
example: mtrx_trnsf #mtrx $x+10 will add 10 to all matrix elements. </p>
<h2>parameters:</h2>
<ol>
  <li>a matrix's name</li>
  <li>an expression parseable by the eval command.  </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mtrx_trnsps</cmdname>
		<description>
			<![CDATA[

<h1>mtrx_trnsps</h1>
<p>calculates the transposed matrix of a matrix. </p>
<h2>parameters:</h2>
<ol>
  <li>a matrix's name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>mul</cmdname>
		<description>
			<![CDATA[

<h1>mul</h1>
<p>multiplies numbers.</p>
<h2>parameters:</h2>
<ul>
  <li>arguments are unlimited, but at least one is required.</li>
</ul>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>num2str</cmdname>
		<description>
			<![CDATA[

<h1>num2str</h1>
<p>converts a floating point number to a string </p>
<h2>parameters:</h2>
<ol>
  <li>a floating point variable's name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>percent</cmdname>
		<description>
			<![CDATA[

<h1>percent</h1>
<p>returns a percentage raito between two vallues. the percentage raito is compared to the first parameter</p>
<h2>parameters:</h2>
<ol>
  <li>a floating point number </li>
  <li>a floating point number</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>plot</cmdname>
		<description>
			<![CDATA[

<h1>plot</h1>
<p>plots a single parameter function. the variable must be given as $x.</p>
<h2>parameters:</h2>
<ol>
  <li>the function</li>
  <li>plot start position</li>
  <li>plot end position</li>
  <li>step size</li>
</ol>
<p>step size is the incrementation number. for example: plot $x 0 10 0,5. this will increment $x from 0 to 10 with a 0,5 step size, so your function will be drawn using 20 points. maximum point number is limited to 15000.</p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>plot_data</cmdname>
		<description>
			<![CDATA[

<h1>plot_data</h1>
<p>plots a datapair. datapair must be a matrix with 2 columns. the first column is the x axis vallue, and the second column is the y axis vallue. </p>
<h2>parameters:</h2>
<ol>
  <li>a matrix's name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>pow</cmdname>
		<description>
			<![CDATA[

<h1>pow</h1>
<p>raises a number to a given power.</p>
<h2>parameters:</h2>
<ol>
  <li>the number to be raised</li>
  <li>the power</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>prgedit</cmdname>
		<description>
			<![CDATA[

<h1>prgedit</h1>
<p>launches the built-in program editor. </p>
<h2>parameters:</h2>
<p>no parameters are required</p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>prglist</cmdname>
		<description>
			<![CDATA[

<h1>prglist</h1>
<p>lists available program files. </p>
<h2>parameters:</h2>
<p>no parameters are required </p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>quadeq</cmdname>
		<description>
			<![CDATA[

<h1>quadeq</h1>
<p>solves a quadratic equation. equations which result in complex numbers can't be solved yet. the equasion first must be normalized to a form of: ax^2+bx+c = 0 </p>
<h2>parameters:</h2>
<ol>
  <li>the factor of a</li>
  <li>the factor of b</li>
  <li>the factor of c   </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>rad2deg</cmdname>
		<description>
			<![CDATA[

<h1>rad2deg</h1>
<p>converts given radians to degrees. the inverse function of deg2rad. this function
ignores the calculator mode.</p>
<h2>parameters:</h2>
<ol>
  <li>a number in radians</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>rand</cmdname>
		<description>
			<![CDATA[

<h1>rand</h1>
<p>generates a random integer number between the given ranges. </p>
<h2>parameters:</h2>
<ol>
  <li>the minimum range</li>
  <li>the maximum range</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>random</cmdname>
		<description>
			<![CDATA[

<h1>random</h1>
<p>generates a random number between the given ranges. </p>
<h2>parameters:</h2>
<ol>
  <li>the minimum range</li>
  <li>the maximum range</li>
  <li>number type. can be float or int.</li>
  <li>a matrix or set name (optional parameter)</li>
</ol>
<p>if a matrix's or a set's name is also specified, then the set or the matrix will be filled with random vallues in the given range. in this case no vallue is returned. </p>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>round</cmdname>
		<description>
			<![CDATA[

<h1>round</h1>
<p>rounds a floating point number to given digits </p>
<h2>parameters:</h2>
<ol>
  <li>a floating point  number</li>
  <li>the digits</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>save</cmdname>
		<description>
			<![CDATA[

<h1>save</h1>
<p>saves a matrix or a set to a file. the program supports the following formats:</p>
<p><strong>matrixes: </strong>csv, xml, xls, bmp </p>
<p><strong>sets:</strong> txt, xml </p>
<p>note: formats are recognised by the file's extension.</p>
<h2>parameters:</h2>
<ol>
  <li>a matrix's or set's name to be saved</li>
  <li>the destination file </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_avg</cmdname>
		<description>
			<![CDATA[

<h1>set_avg</h1>
<p>calculate the average value of a set. 4 average types are supported</p>
<ul>
  <li>normal</li>
  <li>geometric</li>
  <li>harmonic</li>
  <li>square</li>
</ul>
<h2>parameters:</h2>
<ol>
  <li>a set's name </li>
  <li>the average type (see above) </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_count</cmdname>
		<description>
			<![CDATA[

<h1>set_count</h1>
<p>returns the number of elements in a set </p>
<h2>parameters:</h2>
<ol>
  <li>a set's name</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_descart</cmdname>
		<description>
			<![CDATA[

<h1>set_descartes</h1>
<p>produces the descartes product of two sets. the product is stored in a matrix. both input set's must have the same number of elements. </p>
<h2>parameters:</h2>
<ol>
  <li>a set's name</li>
  <li>a set's name  </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_deviat</cmdname>
		<description>
			<![CDATA[

<h1>set_deviat</h1>
<p>returns the <em>deviat</em>ion of a set. two types of <em>deviat</em>ion are supported. these are:</p>
<ul>
  <li>normal</li>
  <li>corigated </li>
</ul>
<h2>parameters:</h2>
<ol>
  <li>a set's name</li>
  <li>a deviation type (see above) </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_dif</cmdname>
		<description>
			<![CDATA[

<h1>set_dif</h1>
<p>returns the difference between two sets. the difference set's elements will be those elements wich are part of the firs set, and are not parts of the second set. </p>
<h2>parameters:</h2>
<ol>
  <li>a set's name</li>
  <li>a set's name  </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_edit</cmdname>
		<description>
			<![CDATA[

<h1>set_edit</h1>
<p>launches the graphical set editor.</p>
<h2>parameters:</h2>
<ol>
  <li>optionaly a set's name</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_max</cmdname>
		<description>
			<![CDATA[

<h1>set_max</h1>
<p>returns the biggest element in a set.</p>
<h2>parameters:</h2>
<ol>
  <li>a set's name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_median</cmdname>
		<description>
			<![CDATA[

<h1>set_median</h1>
<p>returns the median value of a set. </p>
<h2>parameters:</h2>
<ol>
  <li>a set's name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_min</cmdname>
		<description>
			<![CDATA[

<h1>set_min</h1>
<p>returns the smallest element in a set.</p>
<h2>parameters:</h2>
<ol>
  <li>a set's name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_modus</cmdname>
		<description>
			<![CDATA[

<h1>set_modus</h1>
<p>returns the modus of a set. </p>
<h2>parameters:</h2>
<ol>
  <li>a set's name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_push</cmdname>
		<description>
			<![CDATA[

<h1>set_push</h1>
<p>adds elements to an existing set. the items must be sepperated with a ; symbol. </p>
<h2>parameters:</h2>
<ol>
  <li>a set's name</li>
  <li>items to add.  </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_range</cmdname>
		<description>
			<![CDATA[

<h1>set_range</h1>
<p>returns range of elements in a set. the range is calculated from the difference of the biggest and the smallest value in the set. </p>
<h2>parameters:</h2>
<ol>
  <li>a set's name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_rev</cmdname>
		<description>
			<![CDATA[

<h1>set_rev</h1>
<p>reverses the order of the elements in a set. </p>
<h2>parameters:</h2>
<ol>
  <li>a set's name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_rndorder</cmdname>
		<description>
			<![CDATA[

<h1>set_rndorder</h1>
<p>randomizes a set's order. </p>
<h2>parameters:</h2>
<ol>
  <li>a set's name</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_section</cmdname>
		<description>
			<![CDATA[

<h1>set_section</h1>
<p>returns the section of two sets. </p>
<h2>parameters:</h2>
<ol>
  <li>a set's name</li>
  <li>a set's name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_sort</cmdname>
		<description>
			<![CDATA[

<h1>set_sort</h1>
<p>sorts the elements of a set in ascending order.</p>
<h2>parameters:</h2>
<ol>
  <li>a set's name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_sum</cmdname>
		<description>
			<![CDATA[

<h1>set_sum</h1>
<p>returns the sum of a set's elements. </p>
<h2>parameters:</h2>
<ol>
  <li>a set's name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_union</cmdname>
		<description>
			<![CDATA[

<h1>set_union</h1>
<p>creates the union set of two sets </p>
<h2>parameters:</h2>
<ol>
  <li>a set's name</li>
  <li>a set's name  </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>set_unique</cmdname>
		<description>
			<![CDATA[

<h1>set_unique</h1>
<p>removes those values of the set, which are more than one time present in the set.</p>
<h2>parameters:</h2>
<ol>
  <li>a set's name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>sign</cmdname>
		<description>
			<![CDATA[

<h1>sign</h1>
<p>returns the sign of a number. the function returns -1 if the number a negative number (number &lt; 0), 1 if the number is a positive number (number &gt; 0), and a 0 on error (the number is not a number, or it's 0) </p>
<h2>parameters:</h2>
<ol>
  <li>the number you want to inspect </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>sin</cmdname>
		<description>
			<![CDATA[

<h1>sin</h1>
<p>returns the sinus of a number. treats the input number as it's set by the mode command. for more information see the manual of the mode command. </p>
<h2>parameters:</h2>
<ol>
  <li>an angle</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>sinh</cmdname>
		<description>
			<![CDATA[

<h1>sinh</h1>
<p>returns the hyperbolic sinus of a number. treats the input number as it's set by the   mode command. for more information see the manual of the mode command. </p>
<h2>parameters:</h2>
<ol>
  <li>an angle </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>sizeof</cmdname>
		<description>
			<![CDATA[

<h1>sizeof</h1>
<p>returns a variable's size in bytes. this command does not accept parts of matrixes (#mtrx[1;1] form) and sets (@set[1] form). </p>
<h2>parameters:</h2>
<ol>
  <li>the varable name </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>sqr</cmdname>
		<description>
			<![CDATA[

<h1>sqr</h1>
<p>returns the given square of a number, the inverse function of pow.</p>
<h2>parameters:</h2>
<ol>
  <li>the number</li>
  <li>the square that you want</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>sqrt</cmdname>
		<description>
			<![CDATA[

<h1>sqrt</h1>
<p>returns the square root of a number.</p>
<h2>parameters:</h2>
<ol>
  <li>a floating point number</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>str2num</cmdname>
		<description>
			<![CDATA[

<h1>str2num</h1>
<p>converts a string variable to a floating point number </p>
<h2>parameters:</h2>
<ol>
  <li>a string variable's name, or a string, that can be proccessed by the calculator. </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>sub</cmdname>
		<description>
			<![CDATA[

<h1>sub</h1>
<p>subtracts numbers.</p>
<h2>parameters:</h2>
<ul>
  <li>arguments are unlimited, but at least two is required.</li>
</ul>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>tan</cmdname>
		<description>
			<![CDATA[

<h1>tan</h1>
<p>returns the tangent of a number. treats the input number as it's set by the mode command. for more information see the manual of the mode command. </p>
<h2>parameters:</h2>
<ol>
  <li>an angle</li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>tanh</cmdname>
		<description>
			<![CDATA[

<h1>tanh</h1>
<p>returns the hyperbolic tangent of a number. treats the input number as it's set by the   mode command. for more information see the manual of the mode command. </p>
<h2>parameters:</h2>
<ol>
  <li>an angle </li>
</ol>			]]>
		</description>
	</manpage>
	<manpage>
		<cmdname>var_norep</cmdname>
		<description>
			<![CDATA[

<h1>var_norep</h1>
<p>calculates a variation without repeat. </p>
<h2>parameters:</h2>
<ol>
  <li>the number of all elements (n) </li>
  <li>the number of repeating elements (k) </li>
</ol>			]]>
		</description>
	</manpage>
</DataSet1>